package top.linruchang.util;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.sun.istack.internal.NotNull;
import top.linruchang.bean.ReplaceStrAndRegexStr;

import java.util.Arrays;
import java.util.Collection;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 作用：正则工具
 *
 * @author LinRuChang
 * @version 1.0
 * @date 2020/10/22
 * @since 1.8
 */
public class RegexUtil {

    /**
     * <p>
     * description: 原字符串中所有符合regex的正则都替换成replaceStr
     * </p>
     *
     * @param source     源字符串
     * @param replaceStr 替换字符串
     * @param regexs     多个正则表达式
     * @return java.lang.String
     */
    public static String replaceByRegexs(String source,String replaceStr, @NotNull String ...regexs) {
        for(int i = 0; i< regexs.length; i++) {
            source = source.replaceAll(regexs[i], replaceStr);
        }
        return source;
    }

    /**
     * <p>
     * description: ReplaceStrAndRegexStr对象匹配并替换source字符串
     * </p>
     *
     * @param source 原字符串
     * @param replaceStrAndRegexStrs 替换字符串与多个正则
     * @return java.lang.String
     */
    public static String replaceByRegexs( String source, ReplaceStrAndRegexStr... replaceStrAndRegexStrs) {
        String result = source;
        for(int i = 0; i< replaceStrAndRegexStrs.length; i++) {
            final ReplaceStrAndRegexStr rsars = replaceStrAndRegexStrs[i];
            //已经定义替换字符
            if(ObjectUtil.isEmpty(rsars.getReplaceInterface())) {
                for(String regex: rsars.getRegexs()) {
                    result = result.replaceAll(regex, rsars.getReplaceStr());
                }
            //未定义替换字符 - 使用ReplaceInterface进行格式化
            }else {
                final String source2 = result;
                StringBuffer sb = new StringBuffer();
                rsars.getRegexs().forEach(regex -> {
                    Matcher matcher = Pattern.compile(regex).matcher(source2);
                    while(matcher.find()) { //是否找到匹配
                        matcher.appendReplacement(sb, rsars.getReplaceInterface().format(matcher.group()));  //找到中文匹配则开始翻译
                    }
                    matcher.appendTail(sb);
                });
                result = sb.toString();
            }
        }
        return result;
    }
    public static String replaceByRegexs(String source, Collection<ReplaceStrAndRegexStr> replaceStrAndRegexStrs) {
        return replaceByRegexs(source, replaceStrAndRegexStrs.toArray(new ReplaceStrAndRegexStr[replaceStrAndRegexStrs.size()]));
    }
    public static String replaceByRegexs(String source, Map<String,Collection<String>> rules) {
        return replaceByRegexs(source, ReplaceStrAndRegexStr.toReplaceStrAndRegexStrs(rules));
    }

    /**=========================================================================*/

    /**
     * <p>
     * description: 内容与正则是否匹配
     * </p>
     *
     * @param content 内容
     * @param regex   正则表达式
     * @return boolean
     */
    public static boolean isMatch(String content, String regex) {
        //内容、正则都不能为空
        if(StrUtil.isAllNotBlank(content, regex)) {
            return content.matches(regex);
        }
        return false;
    }

    /**
     * <p>
     * description: 是否其中一个正则符合内容
     * </p>
     *
     * @param content 内容
     * @param regexs  多个正则
     * @return boolean
     */
    public static boolean isMatchAnyRegex(String content, String[] regexs) {
        //内容、正则都不能为空
        if(ObjectUtil.isAllNotEmpty(content, regexs)) {
            return Arrays.stream(regexs).anyMatch(regex -> {
                return content.matches(regex);
            });
        }
        return false;
    }
    public static boolean isMatchAnyRegex(String content, Collection<String> regexs) {
        return isMatchAnyRegex(content, regexs.stream().toArray(String[]::new));
    }

    /**
     * <p>
     * description: 是否所有正则都符合内容
     * </p>
     *
     * @param content 内容
     * @param regexs   多个正则
     * @return boolean
     */
    public static boolean isMatchAllRegex(String content, String[] regexs) {
        //内容、正则都不能为空
        if(ObjectUtil.isAllNotEmpty(content, regexs)) {
            return Arrays.stream(regexs).allMatch(regex -> {
                return content.matches(regex);
            });
        }
        return false;
    }
}
